﻿
using System;
using System.Collections.Generic;
using System.Diagnostics.Contracts;
using System.Linq;
using System.Linq.Expressions;
using System.Reflection;
using System.Text;


namespace Isuka.Spiritual.Appendix
{
	partial class ExpressionBuilder
	{
		public void MakeUnary(System.Linq.Expressions.ExpressionType unaryType, System.Type type)
		{
			Contract.Requires(type != null);
			Gate.NotEmpty(exprStack);
			Expression operand = exprStack.Pop();
			Contract.Assume(operand != null);
			var expr = Expression.MakeUnary(unaryType, operand, type);
			exprStack.Push(expr);
		}
		
		public void MakeUnary(System.Linq.Expressions.ExpressionType unaryType, System.Type type, System.Reflection.MethodInfo method)
		{
			Contract.Requires(type != null);
			Gate.NotEmpty(exprStack);
			Expression operand = exprStack.Pop();
			Contract.Assume(operand != null);
			var expr = Expression.MakeUnary(unaryType, operand, type, method);
			exprStack.Push(expr);
		}
		
		public void Negate()
		{
			
			Gate.NotEmpty(exprStack);
			Expression expression = exprStack.Pop();
			Contract.Assume(expression != null);
			var expr = Expression.Negate(expression);
			exprStack.Push(expr);
		}
		
		public void Negate(System.Reflection.MethodInfo method)
		{
			
			Gate.NotEmpty(exprStack);
			Expression expression = exprStack.Pop();
			Contract.Assume(expression != null);
			var expr = Expression.Negate(expression, method);
			exprStack.Push(expr);
		}
		
		public void UnaryPlus()
		{
			
			Gate.NotEmpty(exprStack);
			Expression expression = exprStack.Pop();
			Contract.Assume(expression != null);
			var expr = Expression.UnaryPlus(expression);
			exprStack.Push(expr);
		}
		
		public void UnaryPlus(System.Reflection.MethodInfo method)
		{
			
			Gate.NotEmpty(exprStack);
			Expression expression = exprStack.Pop();
			Contract.Assume(expression != null);
			var expr = Expression.UnaryPlus(expression, method);
			exprStack.Push(expr);
		}
		
		public void NegateChecked()
		{
			
			Gate.NotEmpty(exprStack);
			Expression expression = exprStack.Pop();
			Contract.Assume(expression != null);
			var expr = Expression.NegateChecked(expression);
			exprStack.Push(expr);
		}
		
		public void NegateChecked(System.Reflection.MethodInfo method)
		{
			
			Gate.NotEmpty(exprStack);
			Expression expression = exprStack.Pop();
			Contract.Assume(expression != null);
			var expr = Expression.NegateChecked(expression, method);
			exprStack.Push(expr);
		}
		
		public void Not()
		{
			
			Gate.NotEmpty(exprStack);
			Expression expression = exprStack.Pop();
			Contract.Assume(expression != null);
			var expr = Expression.Not(expression);
			exprStack.Push(expr);
		}
		
		public void Not(System.Reflection.MethodInfo method)
		{
			
			Gate.NotEmpty(exprStack);
			Expression expression = exprStack.Pop();
			Contract.Assume(expression != null);
			var expr = Expression.Not(expression, method);
			exprStack.Push(expr);
		}
		
		public void IsFalse()
		{
			
			Gate.NotEmpty(exprStack);
			Expression expression = exprStack.Pop();
			Contract.Assume(expression != null);
			var expr = Expression.IsFalse(expression);
			exprStack.Push(expr);
		}
		
		public void IsFalse(System.Reflection.MethodInfo method)
		{
			
			Gate.NotEmpty(exprStack);
			Expression expression = exprStack.Pop();
			Contract.Assume(expression != null);
			var expr = Expression.IsFalse(expression, method);
			exprStack.Push(expr);
		}
		
		public void IsTrue()
		{
			
			Gate.NotEmpty(exprStack);
			Expression expression = exprStack.Pop();
			Contract.Assume(expression != null);
			var expr = Expression.IsTrue(expression);
			exprStack.Push(expr);
		}
		
		public void IsTrue(System.Reflection.MethodInfo method)
		{
			
			Gate.NotEmpty(exprStack);
			Expression expression = exprStack.Pop();
			Contract.Assume(expression != null);
			var expr = Expression.IsTrue(expression, method);
			exprStack.Push(expr);
		}
		
		public void OnesComplement()
		{
			
			Gate.NotEmpty(exprStack);
			Expression expression = exprStack.Pop();
			Contract.Assume(expression != null);
			var expr = Expression.OnesComplement(expression);
			exprStack.Push(expr);
		}
		
		public void OnesComplement(System.Reflection.MethodInfo method)
		{
			
			Gate.NotEmpty(exprStack);
			Expression expression = exprStack.Pop();
			Contract.Assume(expression != null);
			var expr = Expression.OnesComplement(expression, method);
			exprStack.Push(expr);
		}
		
		public void TypeAs(System.Type type)
		{
			Contract.Requires(type != null);
			Gate.NotEmpty(exprStack);
			Expression expression = exprStack.Pop();
			Contract.Assume(expression != null);
			var expr = Expression.TypeAs(expression, type);
			exprStack.Push(expr);
		}
		
		public void Unbox(System.Type type)
		{
			Contract.Requires(type != null);
			Gate.NotEmpty(exprStack);
			Expression expression = exprStack.Pop();
			Contract.Assume(expression != null);
			var expr = Expression.Unbox(expression, type);
			exprStack.Push(expr);
		}
		
		public void Convert(System.Type type)
		{
			Contract.Requires(type != null);
			Gate.NotEmpty(exprStack);
			Expression expression = exprStack.Pop();
			Contract.Assume(expression != null);
			var expr = Expression.Convert(expression, type);
			exprStack.Push(expr);
		}
		
		public void Convert(System.Type type, System.Reflection.MethodInfo method)
		{
			Contract.Requires(type != null);
			Gate.NotEmpty(exprStack);
			Expression expression = exprStack.Pop();
			Contract.Assume(expression != null);
			var expr = Expression.Convert(expression, type, method);
			exprStack.Push(expr);
		}
		
		public void ConvertChecked(System.Type type)
		{
			Contract.Requires(type != null);
			Gate.NotEmpty(exprStack);
			Expression expression = exprStack.Pop();
			Contract.Assume(expression != null);
			var expr = Expression.ConvertChecked(expression, type);
			exprStack.Push(expr);
		}
		
		public void ConvertChecked(System.Type type, System.Reflection.MethodInfo method)
		{
			Contract.Requires(type != null);
			Gate.NotEmpty(exprStack);
			Expression expression = exprStack.Pop();
			Contract.Assume(expression != null);
			var expr = Expression.ConvertChecked(expression, type, method);
			exprStack.Push(expr);
		}
		
		public void ArrayLength(System.Linq.Expressions.Expression array)
		{
			Contract.Requires(array != null);
			Gate.NotEmpty(exprStack);
			Expression expression = exprStack.Pop();
			Contract.Assume(expression != null);
			var expr = Expression.ArrayLength(array);
			exprStack.Push(expr);
		}
		
		public void Quote()
		{
			
			Gate.NotEmpty(exprStack);
			Expression expression = exprStack.Pop();
			Contract.Assume(expression != null);
			var expr = Expression.Quote(expression);
			exprStack.Push(expr);
		}
		
		public void Rethrow()
		{
			
			Gate.NotEmpty(exprStack);
			Expression expression = exprStack.Pop();
			Contract.Assume(expression != null);
			var expr = Expression.Rethrow();
			exprStack.Push(expr);
		}
		
		public void Rethrow(System.Type type)
		{
			Contract.Requires(type != null);
			Gate.NotEmpty(exprStack);
			Expression expression = exprStack.Pop();
			Contract.Assume(expression != null);
			var expr = Expression.Rethrow(type);
			exprStack.Push(expr);
		}
		
		public void Throw(System.Linq.Expressions.Expression value)
		{
			
			Gate.NotEmpty(exprStack);
			Expression expression = exprStack.Pop();
			Contract.Assume(expression != null);
			var expr = Expression.Throw(value);
			exprStack.Push(expr);
		}
		
		public void Throw(System.Linq.Expressions.Expression value, System.Type type)
		{
			Contract.Requires(type != null);
			Gate.NotEmpty(exprStack);
			Expression expression = exprStack.Pop();
			Contract.Assume(expression != null);
			var expr = Expression.Throw(value, type);
			exprStack.Push(expr);
		}
		
		public void Increment()
		{
			
			Gate.NotEmpty(exprStack);
			Expression expression = exprStack.Pop();
			Contract.Assume(expression != null);
			var expr = Expression.Increment(expression);
			exprStack.Push(expr);
		}
		
		public void Increment(System.Reflection.MethodInfo method)
		{
			
			Gate.NotEmpty(exprStack);
			Expression expression = exprStack.Pop();
			Contract.Assume(expression != null);
			var expr = Expression.Increment(expression, method);
			exprStack.Push(expr);
		}
		
		public void Decrement()
		{
			
			Gate.NotEmpty(exprStack);
			Expression expression = exprStack.Pop();
			Contract.Assume(expression != null);
			var expr = Expression.Decrement(expression);
			exprStack.Push(expr);
		}
		
		public void Decrement(System.Reflection.MethodInfo method)
		{
			
			Gate.NotEmpty(exprStack);
			Expression expression = exprStack.Pop();
			Contract.Assume(expression != null);
			var expr = Expression.Decrement(expression, method);
			exprStack.Push(expr);
		}
		
		public void PreIncrementAssign()
		{
			
			Gate.NotEmpty(exprStack);
			Expression expression = exprStack.Pop();
			Contract.Assume(expression != null);
			var expr = Expression.PreIncrementAssign(expression);
			exprStack.Push(expr);
		}
		
		public void PreIncrementAssign(System.Reflection.MethodInfo method)
		{
			
			Gate.NotEmpty(exprStack);
			Expression expression = exprStack.Pop();
			Contract.Assume(expression != null);
			var expr = Expression.PreIncrementAssign(expression, method);
			exprStack.Push(expr);
		}
		
		public void PreDecrementAssign()
		{
			
			Gate.NotEmpty(exprStack);
			Expression expression = exprStack.Pop();
			Contract.Assume(expression != null);
			var expr = Expression.PreDecrementAssign(expression);
			exprStack.Push(expr);
		}
		
		public void PreDecrementAssign(System.Reflection.MethodInfo method)
		{
			
			Gate.NotEmpty(exprStack);
			Expression expression = exprStack.Pop();
			Contract.Assume(expression != null);
			var expr = Expression.PreDecrementAssign(expression, method);
			exprStack.Push(expr);
		}
		
		public void PostIncrementAssign()
		{
			
			Gate.NotEmpty(exprStack);
			Expression expression = exprStack.Pop();
			Contract.Assume(expression != null);
			var expr = Expression.PostIncrementAssign(expression);
			exprStack.Push(expr);
		}
		
		public void PostIncrementAssign(System.Reflection.MethodInfo method)
		{
			
			Gate.NotEmpty(exprStack);
			Expression expression = exprStack.Pop();
			Contract.Assume(expression != null);
			var expr = Expression.PostIncrementAssign(expression, method);
			exprStack.Push(expr);
		}
		
		public void PostDecrementAssign()
		{
			
			Gate.NotEmpty(exprStack);
			Expression expression = exprStack.Pop();
			Contract.Assume(expression != null);
			var expr = Expression.PostDecrementAssign(expression);
			exprStack.Push(expr);
		}
		
		public void PostDecrementAssign(System.Reflection.MethodInfo method)
		{
			
			Gate.NotEmpty(exprStack);
			Expression expression = exprStack.Pop();
			Contract.Assume(expression != null);
			var expr = Expression.PostDecrementAssign(expression, method);
			exprStack.Push(expr);
		}
		
		public void ExclusiveOr(System.Reflection.MethodInfo method)
		{
			
			Gate.NotEmpty(exprStack);
			Expression right = exprStack.Pop();
			Contract.Assume(right != null);
			Gate.NotEmpty(exprStack);
			Expression left = exprStack.Pop();
			Contract.Assume(left != null);
			var expr = Expression.ExclusiveOr(left, right, method);
			exprStack.Push(expr);
		}
		
		public void ExclusiveOrAssign()
		{
			
			Gate.NotEmpty(exprStack);
			Expression right = exprStack.Pop();
			Contract.Assume(right != null);
			Gate.NotEmpty(exprStack);
			Expression left = exprStack.Pop();
			Contract.Assume(left != null);
			var expr = Expression.ExclusiveOrAssign(left, right);
			exprStack.Push(expr);
		}
		
		public void ExclusiveOrAssign(System.Reflection.MethodInfo method)
		{
			
			Gate.NotEmpty(exprStack);
			Expression right = exprStack.Pop();
			Contract.Assume(right != null);
			Gate.NotEmpty(exprStack);
			Expression left = exprStack.Pop();
			Contract.Assume(left != null);
			var expr = Expression.ExclusiveOrAssign(left, right, method);
			exprStack.Push(expr);
		}
		
		public void ExclusiveOrAssign(System.Reflection.MethodInfo method, System.Linq.Expressions.LambdaExpression conversion)
		{
			
			Gate.NotEmpty(exprStack);
			Expression right = exprStack.Pop();
			Contract.Assume(right != null);
			Gate.NotEmpty(exprStack);
			Expression left = exprStack.Pop();
			Contract.Assume(left != null);
			var expr = Expression.ExclusiveOrAssign(left, right, method, conversion);
			exprStack.Push(expr);
		}
		
		public void Power()
		{
			
			Gate.NotEmpty(exprStack);
			Expression right = exprStack.Pop();
			Contract.Assume(right != null);
			Gate.NotEmpty(exprStack);
			Expression left = exprStack.Pop();
			Contract.Assume(left != null);
			var expr = Expression.Power(left, right);
			exprStack.Push(expr);
		}
		
		public void Power(System.Reflection.MethodInfo method)
		{
			
			Gate.NotEmpty(exprStack);
			Expression right = exprStack.Pop();
			Contract.Assume(right != null);
			Gate.NotEmpty(exprStack);
			Expression left = exprStack.Pop();
			Contract.Assume(left != null);
			var expr = Expression.Power(left, right, method);
			exprStack.Push(expr);
		}
		
		public void PowerAssign()
		{
			
			Gate.NotEmpty(exprStack);
			Expression right = exprStack.Pop();
			Contract.Assume(right != null);
			Gate.NotEmpty(exprStack);
			Expression left = exprStack.Pop();
			Contract.Assume(left != null);
			var expr = Expression.PowerAssign(left, right);
			exprStack.Push(expr);
		}
		
		public void PowerAssign(System.Reflection.MethodInfo method)
		{
			
			Gate.NotEmpty(exprStack);
			Expression right = exprStack.Pop();
			Contract.Assume(right != null);
			Gate.NotEmpty(exprStack);
			Expression left = exprStack.Pop();
			Contract.Assume(left != null);
			var expr = Expression.PowerAssign(left, right, method);
			exprStack.Push(expr);
		}
		
		public void PowerAssign(System.Reflection.MethodInfo method, System.Linq.Expressions.LambdaExpression conversion)
		{
			
			Gate.NotEmpty(exprStack);
			Expression right = exprStack.Pop();
			Contract.Assume(right != null);
			Gate.NotEmpty(exprStack);
			Expression left = exprStack.Pop();
			Contract.Assume(left != null);
			var expr = Expression.PowerAssign(left, right, method, conversion);
			exprStack.Push(expr);
		}
		
		public void ArrayIndex(System.Linq.Expressions.Expression array, System.Linq.Expressions.Expression index)
		{
			Contract.Requires(array != null);
			Gate.NotEmpty(exprStack);
			Expression right = exprStack.Pop();
			Contract.Assume(right != null);
			Gate.NotEmpty(exprStack);
			Expression left = exprStack.Pop();
			Contract.Assume(left != null);
			var expr = Expression.ArrayIndex(array, index);
			exprStack.Push(expr);
		}
		
		public void Constant(object value)
		{
			var expr = Expression.Constant(value);
			exprStack.Push(expr);
		}
		
		public void Constant(object value, System.Type type)
		{
			var expr = Expression.Constant(value, type);
			exprStack.Push(expr);
		}
		
		public void Assign()
		{
			
			Gate.NotEmpty(exprStack);
			Expression right = exprStack.Pop();
			Contract.Assume(right != null);
			Gate.NotEmpty(exprStack);
			Expression left = exprStack.Pop();
			Contract.Assume(left != null);
			var expr = Expression.Assign(left, right);
			exprStack.Push(expr);
		}
		
		public void MakeBinary(System.Linq.Expressions.ExpressionType binaryType)
		{
			
			Gate.NotEmpty(exprStack);
			Expression right = exprStack.Pop();
			Contract.Assume(right != null);
			Gate.NotEmpty(exprStack);
			Expression left = exprStack.Pop();
			Contract.Assume(left != null);
			var expr = Expression.MakeBinary(binaryType, left, right);
			exprStack.Push(expr);
		}
		
		public void MakeBinary(System.Linq.Expressions.ExpressionType binaryType, bool liftToNull, System.Reflection.MethodInfo method)
		{
			
			Gate.NotEmpty(exprStack);
			Expression right = exprStack.Pop();
			Contract.Assume(right != null);
			Gate.NotEmpty(exprStack);
			Expression left = exprStack.Pop();
			Contract.Assume(left != null);
			var expr = Expression.MakeBinary(binaryType, left, right, liftToNull, method);
			exprStack.Push(expr);
		}
		
		public void MakeBinary(System.Linq.Expressions.ExpressionType binaryType, bool liftToNull, System.Reflection.MethodInfo method, System.Linq.Expressions.LambdaExpression conversion)
		{
			
			Gate.NotEmpty(exprStack);
			Expression right = exprStack.Pop();
			Contract.Assume(right != null);
			Gate.NotEmpty(exprStack);
			Expression left = exprStack.Pop();
			Contract.Assume(left != null);
			var expr = Expression.MakeBinary(binaryType, left, right, liftToNull, method, conversion);
			exprStack.Push(expr);
		}
		
		public void Equal()
		{
			
			Gate.NotEmpty(exprStack);
			Expression right = exprStack.Pop();
			Contract.Assume(right != null);
			Gate.NotEmpty(exprStack);
			Expression left = exprStack.Pop();
			Contract.Assume(left != null);
			var expr = Expression.Equal(left, right);
			exprStack.Push(expr);
		}
		
		public void Equal(bool liftToNull, System.Reflection.MethodInfo method)
		{
			
			Gate.NotEmpty(exprStack);
			Expression right = exprStack.Pop();
			Contract.Assume(right != null);
			Gate.NotEmpty(exprStack);
			Expression left = exprStack.Pop();
			Contract.Assume(left != null);
			var expr = Expression.Equal(left, right, liftToNull, method);
			exprStack.Push(expr);
		}
		
		public void ReferenceEqual()
		{
			
			Gate.NotEmpty(exprStack);
			Expression right = exprStack.Pop();
			Contract.Assume(right != null);
			Gate.NotEmpty(exprStack);
			Expression left = exprStack.Pop();
			Contract.Assume(left != null);
			var expr = Expression.ReferenceEqual(left, right);
			exprStack.Push(expr);
		}
		
		public void NotEqual()
		{
			
			Gate.NotEmpty(exprStack);
			Expression right = exprStack.Pop();
			Contract.Assume(right != null);
			Gate.NotEmpty(exprStack);
			Expression left = exprStack.Pop();
			Contract.Assume(left != null);
			var expr = Expression.NotEqual(left, right);
			exprStack.Push(expr);
		}
		
		public void NotEqual(bool liftToNull, System.Reflection.MethodInfo method)
		{
			
			Gate.NotEmpty(exprStack);
			Expression right = exprStack.Pop();
			Contract.Assume(right != null);
			Gate.NotEmpty(exprStack);
			Expression left = exprStack.Pop();
			Contract.Assume(left != null);
			var expr = Expression.NotEqual(left, right, liftToNull, method);
			exprStack.Push(expr);
		}
		
		public void ReferenceNotEqual()
		{
			
			Gate.NotEmpty(exprStack);
			Expression right = exprStack.Pop();
			Contract.Assume(right != null);
			Gate.NotEmpty(exprStack);
			Expression left = exprStack.Pop();
			Contract.Assume(left != null);
			var expr = Expression.ReferenceNotEqual(left, right);
			exprStack.Push(expr);
		}
		
		public void GreaterThan()
		{
			
			Gate.NotEmpty(exprStack);
			Expression right = exprStack.Pop();
			Contract.Assume(right != null);
			Gate.NotEmpty(exprStack);
			Expression left = exprStack.Pop();
			Contract.Assume(left != null);
			var expr = Expression.GreaterThan(left, right);
			exprStack.Push(expr);
		}
		
		public void GreaterThan(bool liftToNull, System.Reflection.MethodInfo method)
		{
			
			Gate.NotEmpty(exprStack);
			Expression right = exprStack.Pop();
			Contract.Assume(right != null);
			Gate.NotEmpty(exprStack);
			Expression left = exprStack.Pop();
			Contract.Assume(left != null);
			var expr = Expression.GreaterThan(left, right, liftToNull, method);
			exprStack.Push(expr);
		}
		
		public void LessThan()
		{
			
			Gate.NotEmpty(exprStack);
			Expression right = exprStack.Pop();
			Contract.Assume(right != null);
			Gate.NotEmpty(exprStack);
			Expression left = exprStack.Pop();
			Contract.Assume(left != null);
			var expr = Expression.LessThan(left, right);
			exprStack.Push(expr);
		}
		
		public void LessThan(bool liftToNull, System.Reflection.MethodInfo method)
		{
			
			Gate.NotEmpty(exprStack);
			Expression right = exprStack.Pop();
			Contract.Assume(right != null);
			Gate.NotEmpty(exprStack);
			Expression left = exprStack.Pop();
			Contract.Assume(left != null);
			var expr = Expression.LessThan(left, right, liftToNull, method);
			exprStack.Push(expr);
		}
		
		public void GreaterThanOrEqual()
		{
			
			Gate.NotEmpty(exprStack);
			Expression right = exprStack.Pop();
			Contract.Assume(right != null);
			Gate.NotEmpty(exprStack);
			Expression left = exprStack.Pop();
			Contract.Assume(left != null);
			var expr = Expression.GreaterThanOrEqual(left, right);
			exprStack.Push(expr);
		}
		
		public void GreaterThanOrEqual(bool liftToNull, System.Reflection.MethodInfo method)
		{
			
			Gate.NotEmpty(exprStack);
			Expression right = exprStack.Pop();
			Contract.Assume(right != null);
			Gate.NotEmpty(exprStack);
			Expression left = exprStack.Pop();
			Contract.Assume(left != null);
			var expr = Expression.GreaterThanOrEqual(left, right, liftToNull, method);
			exprStack.Push(expr);
		}
		
		public void LessThanOrEqual()
		{
			
			Gate.NotEmpty(exprStack);
			Expression right = exprStack.Pop();
			Contract.Assume(right != null);
			Gate.NotEmpty(exprStack);
			Expression left = exprStack.Pop();
			Contract.Assume(left != null);
			var expr = Expression.LessThanOrEqual(left, right);
			exprStack.Push(expr);
		}
		
		public void LessThanOrEqual(bool liftToNull, System.Reflection.MethodInfo method)
		{
			
			Gate.NotEmpty(exprStack);
			Expression right = exprStack.Pop();
			Contract.Assume(right != null);
			Gate.NotEmpty(exprStack);
			Expression left = exprStack.Pop();
			Contract.Assume(left != null);
			var expr = Expression.LessThanOrEqual(left, right, liftToNull, method);
			exprStack.Push(expr);
		}
		
		public void AndAlso()
		{
			
			Gate.NotEmpty(exprStack);
			Expression right = exprStack.Pop();
			Contract.Assume(right != null);
			Gate.NotEmpty(exprStack);
			Expression left = exprStack.Pop();
			Contract.Assume(left != null);
			var expr = Expression.AndAlso(left, right);
			exprStack.Push(expr);
		}
		
		public void AndAlso(System.Reflection.MethodInfo method)
		{
			
			Gate.NotEmpty(exprStack);
			Expression right = exprStack.Pop();
			Contract.Assume(right != null);
			Gate.NotEmpty(exprStack);
			Expression left = exprStack.Pop();
			Contract.Assume(left != null);
			var expr = Expression.AndAlso(left, right, method);
			exprStack.Push(expr);
		}
		
		public void OrElse()
		{
			
			Gate.NotEmpty(exprStack);
			Expression right = exprStack.Pop();
			Contract.Assume(right != null);
			Gate.NotEmpty(exprStack);
			Expression left = exprStack.Pop();
			Contract.Assume(left != null);
			var expr = Expression.OrElse(left, right);
			exprStack.Push(expr);
		}
		
		public void OrElse(System.Reflection.MethodInfo method)
		{
			
			Gate.NotEmpty(exprStack);
			Expression right = exprStack.Pop();
			Contract.Assume(right != null);
			Gate.NotEmpty(exprStack);
			Expression left = exprStack.Pop();
			Contract.Assume(left != null);
			var expr = Expression.OrElse(left, right, method);
			exprStack.Push(expr);
		}
		
		public void Coalesce()
		{
			
			Gate.NotEmpty(exprStack);
			Expression right = exprStack.Pop();
			Contract.Assume(right != null);
			Gate.NotEmpty(exprStack);
			Expression left = exprStack.Pop();
			Contract.Assume(left != null);
			var expr = Expression.Coalesce(left, right);
			exprStack.Push(expr);
		}
		
		public void Coalesce(System.Linq.Expressions.LambdaExpression conversion)
		{
			
			Gate.NotEmpty(exprStack);
			Expression right = exprStack.Pop();
			Contract.Assume(right != null);
			Gate.NotEmpty(exprStack);
			Expression left = exprStack.Pop();
			Contract.Assume(left != null);
			var expr = Expression.Coalesce(left, right, conversion);
			exprStack.Push(expr);
		}
		
		public void Add()
		{
			
			Gate.NotEmpty(exprStack);
			Expression right = exprStack.Pop();
			Contract.Assume(right != null);
			Gate.NotEmpty(exprStack);
			Expression left = exprStack.Pop();
			Contract.Assume(left != null);
			var expr = Expression.Add(left, right);
			exprStack.Push(expr);
		}
		
		public void Add(System.Reflection.MethodInfo method)
		{
			
			Gate.NotEmpty(exprStack);
			Expression right = exprStack.Pop();
			Contract.Assume(right != null);
			Gate.NotEmpty(exprStack);
			Expression left = exprStack.Pop();
			Contract.Assume(left != null);
			var expr = Expression.Add(left, right, method);
			exprStack.Push(expr);
		}
		
		public void AddAssign()
		{
			
			Gate.NotEmpty(exprStack);
			Expression right = exprStack.Pop();
			Contract.Assume(right != null);
			Gate.NotEmpty(exprStack);
			Expression left = exprStack.Pop();
			Contract.Assume(left != null);
			var expr = Expression.AddAssign(left, right);
			exprStack.Push(expr);
		}
		
		public void AddAssign(System.Reflection.MethodInfo method)
		{
			
			Gate.NotEmpty(exprStack);
			Expression right = exprStack.Pop();
			Contract.Assume(right != null);
			Gate.NotEmpty(exprStack);
			Expression left = exprStack.Pop();
			Contract.Assume(left != null);
			var expr = Expression.AddAssign(left, right, method);
			exprStack.Push(expr);
		}
		
		public void AddAssign(System.Reflection.MethodInfo method, System.Linq.Expressions.LambdaExpression conversion)
		{
			
			Gate.NotEmpty(exprStack);
			Expression right = exprStack.Pop();
			Contract.Assume(right != null);
			Gate.NotEmpty(exprStack);
			Expression left = exprStack.Pop();
			Contract.Assume(left != null);
			var expr = Expression.AddAssign(left, right, method, conversion);
			exprStack.Push(expr);
		}
		
		public void AddAssignChecked()
		{
			
			Gate.NotEmpty(exprStack);
			Expression right = exprStack.Pop();
			Contract.Assume(right != null);
			Gate.NotEmpty(exprStack);
			Expression left = exprStack.Pop();
			Contract.Assume(left != null);
			var expr = Expression.AddAssignChecked(left, right);
			exprStack.Push(expr);
		}
		
		public void AddAssignChecked(System.Reflection.MethodInfo method)
		{
			
			Gate.NotEmpty(exprStack);
			Expression right = exprStack.Pop();
			Contract.Assume(right != null);
			Gate.NotEmpty(exprStack);
			Expression left = exprStack.Pop();
			Contract.Assume(left != null);
			var expr = Expression.AddAssignChecked(left, right, method);
			exprStack.Push(expr);
		}
		
		public void AddAssignChecked(System.Reflection.MethodInfo method, System.Linq.Expressions.LambdaExpression conversion)
		{
			
			Gate.NotEmpty(exprStack);
			Expression right = exprStack.Pop();
			Contract.Assume(right != null);
			Gate.NotEmpty(exprStack);
			Expression left = exprStack.Pop();
			Contract.Assume(left != null);
			var expr = Expression.AddAssignChecked(left, right, method, conversion);
			exprStack.Push(expr);
		}
		
		public void AddChecked()
		{
			
			Gate.NotEmpty(exprStack);
			Expression right = exprStack.Pop();
			Contract.Assume(right != null);
			Gate.NotEmpty(exprStack);
			Expression left = exprStack.Pop();
			Contract.Assume(left != null);
			var expr = Expression.AddChecked(left, right);
			exprStack.Push(expr);
		}
		
		public void AddChecked(System.Reflection.MethodInfo method)
		{
			
			Gate.NotEmpty(exprStack);
			Expression right = exprStack.Pop();
			Contract.Assume(right != null);
			Gate.NotEmpty(exprStack);
			Expression left = exprStack.Pop();
			Contract.Assume(left != null);
			var expr = Expression.AddChecked(left, right, method);
			exprStack.Push(expr);
		}
		
		public void Subtract()
		{
			
			Gate.NotEmpty(exprStack);
			Expression right = exprStack.Pop();
			Contract.Assume(right != null);
			Gate.NotEmpty(exprStack);
			Expression left = exprStack.Pop();
			Contract.Assume(left != null);
			var expr = Expression.Subtract(left, right);
			exprStack.Push(expr);
		}
		
		public void Subtract(System.Reflection.MethodInfo method)
		{
			
			Gate.NotEmpty(exprStack);
			Expression right = exprStack.Pop();
			Contract.Assume(right != null);
			Gate.NotEmpty(exprStack);
			Expression left = exprStack.Pop();
			Contract.Assume(left != null);
			var expr = Expression.Subtract(left, right, method);
			exprStack.Push(expr);
		}
		
		public void SubtractAssign()
		{
			
			Gate.NotEmpty(exprStack);
			Expression right = exprStack.Pop();
			Contract.Assume(right != null);
			Gate.NotEmpty(exprStack);
			Expression left = exprStack.Pop();
			Contract.Assume(left != null);
			var expr = Expression.SubtractAssign(left, right);
			exprStack.Push(expr);
		}
		
		public void SubtractAssign(System.Reflection.MethodInfo method)
		{
			
			Gate.NotEmpty(exprStack);
			Expression right = exprStack.Pop();
			Contract.Assume(right != null);
			Gate.NotEmpty(exprStack);
			Expression left = exprStack.Pop();
			Contract.Assume(left != null);
			var expr = Expression.SubtractAssign(left, right, method);
			exprStack.Push(expr);
		}
		
		public void SubtractAssign(System.Reflection.MethodInfo method, System.Linq.Expressions.LambdaExpression conversion)
		{
			
			Gate.NotEmpty(exprStack);
			Expression right = exprStack.Pop();
			Contract.Assume(right != null);
			Gate.NotEmpty(exprStack);
			Expression left = exprStack.Pop();
			Contract.Assume(left != null);
			var expr = Expression.SubtractAssign(left, right, method, conversion);
			exprStack.Push(expr);
		}
		
		public void SubtractAssignChecked()
		{
			
			Gate.NotEmpty(exprStack);
			Expression right = exprStack.Pop();
			Contract.Assume(right != null);
			Gate.NotEmpty(exprStack);
			Expression left = exprStack.Pop();
			Contract.Assume(left != null);
			var expr = Expression.SubtractAssignChecked(left, right);
			exprStack.Push(expr);
		}
		
		public void SubtractAssignChecked(System.Reflection.MethodInfo method)
		{
			
			Gate.NotEmpty(exprStack);
			Expression right = exprStack.Pop();
			Contract.Assume(right != null);
			Gate.NotEmpty(exprStack);
			Expression left = exprStack.Pop();
			Contract.Assume(left != null);
			var expr = Expression.SubtractAssignChecked(left, right, method);
			exprStack.Push(expr);
		}
		
		public void SubtractAssignChecked(System.Reflection.MethodInfo method, System.Linq.Expressions.LambdaExpression conversion)
		{
			
			Gate.NotEmpty(exprStack);
			Expression right = exprStack.Pop();
			Contract.Assume(right != null);
			Gate.NotEmpty(exprStack);
			Expression left = exprStack.Pop();
			Contract.Assume(left != null);
			var expr = Expression.SubtractAssignChecked(left, right, method, conversion);
			exprStack.Push(expr);
		}
		
		public void SubtractChecked()
		{
			
			Gate.NotEmpty(exprStack);
			Expression right = exprStack.Pop();
			Contract.Assume(right != null);
			Gate.NotEmpty(exprStack);
			Expression left = exprStack.Pop();
			Contract.Assume(left != null);
			var expr = Expression.SubtractChecked(left, right);
			exprStack.Push(expr);
		}
		
		public void SubtractChecked(System.Reflection.MethodInfo method)
		{
			
			Gate.NotEmpty(exprStack);
			Expression right = exprStack.Pop();
			Contract.Assume(right != null);
			Gate.NotEmpty(exprStack);
			Expression left = exprStack.Pop();
			Contract.Assume(left != null);
			var expr = Expression.SubtractChecked(left, right, method);
			exprStack.Push(expr);
		}
		
		public void Divide()
		{
			
			Gate.NotEmpty(exprStack);
			Expression right = exprStack.Pop();
			Contract.Assume(right != null);
			Gate.NotEmpty(exprStack);
			Expression left = exprStack.Pop();
			Contract.Assume(left != null);
			var expr = Expression.Divide(left, right);
			exprStack.Push(expr);
		}
		
		public void Divide(System.Reflection.MethodInfo method)
		{
			
			Gate.NotEmpty(exprStack);
			Expression right = exprStack.Pop();
			Contract.Assume(right != null);
			Gate.NotEmpty(exprStack);
			Expression left = exprStack.Pop();
			Contract.Assume(left != null);
			var expr = Expression.Divide(left, right, method);
			exprStack.Push(expr);
		}
		
		public void DivideAssign()
		{
			
			Gate.NotEmpty(exprStack);
			Expression right = exprStack.Pop();
			Contract.Assume(right != null);
			Gate.NotEmpty(exprStack);
			Expression left = exprStack.Pop();
			Contract.Assume(left != null);
			var expr = Expression.DivideAssign(left, right);
			exprStack.Push(expr);
		}
		
		public void DivideAssign(System.Reflection.MethodInfo method)
		{
			
			Gate.NotEmpty(exprStack);
			Expression right = exprStack.Pop();
			Contract.Assume(right != null);
			Gate.NotEmpty(exprStack);
			Expression left = exprStack.Pop();
			Contract.Assume(left != null);
			var expr = Expression.DivideAssign(left, right, method);
			exprStack.Push(expr);
		}
		
		public void DivideAssign(System.Reflection.MethodInfo method, System.Linq.Expressions.LambdaExpression conversion)
		{
			
			Gate.NotEmpty(exprStack);
			Expression right = exprStack.Pop();
			Contract.Assume(right != null);
			Gate.NotEmpty(exprStack);
			Expression left = exprStack.Pop();
			Contract.Assume(left != null);
			var expr = Expression.DivideAssign(left, right, method, conversion);
			exprStack.Push(expr);
		}
		
		public void Modulo()
		{
			
			Gate.NotEmpty(exprStack);
			Expression right = exprStack.Pop();
			Contract.Assume(right != null);
			Gate.NotEmpty(exprStack);
			Expression left = exprStack.Pop();
			Contract.Assume(left != null);
			var expr = Expression.Modulo(left, right);
			exprStack.Push(expr);
		}
		
		public void Modulo(System.Reflection.MethodInfo method)
		{
			
			Gate.NotEmpty(exprStack);
			Expression right = exprStack.Pop();
			Contract.Assume(right != null);
			Gate.NotEmpty(exprStack);
			Expression left = exprStack.Pop();
			Contract.Assume(left != null);
			var expr = Expression.Modulo(left, right, method);
			exprStack.Push(expr);
		}
		
		public void ModuloAssign()
		{
			
			Gate.NotEmpty(exprStack);
			Expression right = exprStack.Pop();
			Contract.Assume(right != null);
			Gate.NotEmpty(exprStack);
			Expression left = exprStack.Pop();
			Contract.Assume(left != null);
			var expr = Expression.ModuloAssign(left, right);
			exprStack.Push(expr);
		}
		
		public void ModuloAssign(System.Reflection.MethodInfo method)
		{
			
			Gate.NotEmpty(exprStack);
			Expression right = exprStack.Pop();
			Contract.Assume(right != null);
			Gate.NotEmpty(exprStack);
			Expression left = exprStack.Pop();
			Contract.Assume(left != null);
			var expr = Expression.ModuloAssign(left, right, method);
			exprStack.Push(expr);
		}
		
		public void ModuloAssign(System.Reflection.MethodInfo method, System.Linq.Expressions.LambdaExpression conversion)
		{
			
			Gate.NotEmpty(exprStack);
			Expression right = exprStack.Pop();
			Contract.Assume(right != null);
			Gate.NotEmpty(exprStack);
			Expression left = exprStack.Pop();
			Contract.Assume(left != null);
			var expr = Expression.ModuloAssign(left, right, method, conversion);
			exprStack.Push(expr);
		}
		
		public void Multiply()
		{
			
			Gate.NotEmpty(exprStack);
			Expression right = exprStack.Pop();
			Contract.Assume(right != null);
			Gate.NotEmpty(exprStack);
			Expression left = exprStack.Pop();
			Contract.Assume(left != null);
			var expr = Expression.Multiply(left, right);
			exprStack.Push(expr);
		}
		
		public void Multiply(System.Reflection.MethodInfo method)
		{
			
			Gate.NotEmpty(exprStack);
			Expression right = exprStack.Pop();
			Contract.Assume(right != null);
			Gate.NotEmpty(exprStack);
			Expression left = exprStack.Pop();
			Contract.Assume(left != null);
			var expr = Expression.Multiply(left, right, method);
			exprStack.Push(expr);
		}
		
		public void MultiplyAssign()
		{
			
			Gate.NotEmpty(exprStack);
			Expression right = exprStack.Pop();
			Contract.Assume(right != null);
			Gate.NotEmpty(exprStack);
			Expression left = exprStack.Pop();
			Contract.Assume(left != null);
			var expr = Expression.MultiplyAssign(left, right);
			exprStack.Push(expr);
		}
		
		public void MultiplyAssign(System.Reflection.MethodInfo method)
		{
			
			Gate.NotEmpty(exprStack);
			Expression right = exprStack.Pop();
			Contract.Assume(right != null);
			Gate.NotEmpty(exprStack);
			Expression left = exprStack.Pop();
			Contract.Assume(left != null);
			var expr = Expression.MultiplyAssign(left, right, method);
			exprStack.Push(expr);
		}
		
		public void MultiplyAssign(System.Reflection.MethodInfo method, System.Linq.Expressions.LambdaExpression conversion)
		{
			
			Gate.NotEmpty(exprStack);
			Expression right = exprStack.Pop();
			Contract.Assume(right != null);
			Gate.NotEmpty(exprStack);
			Expression left = exprStack.Pop();
			Contract.Assume(left != null);
			var expr = Expression.MultiplyAssign(left, right, method, conversion);
			exprStack.Push(expr);
		}
		
		public void MultiplyAssignChecked()
		{
			
			Gate.NotEmpty(exprStack);
			Expression right = exprStack.Pop();
			Contract.Assume(right != null);
			Gate.NotEmpty(exprStack);
			Expression left = exprStack.Pop();
			Contract.Assume(left != null);
			var expr = Expression.MultiplyAssignChecked(left, right);
			exprStack.Push(expr);
		}
		
		public void MultiplyAssignChecked(System.Reflection.MethodInfo method)
		{
			
			Gate.NotEmpty(exprStack);
			Expression right = exprStack.Pop();
			Contract.Assume(right != null);
			Gate.NotEmpty(exprStack);
			Expression left = exprStack.Pop();
			Contract.Assume(left != null);
			var expr = Expression.MultiplyAssignChecked(left, right, method);
			exprStack.Push(expr);
		}
		
		public void MultiplyAssignChecked(System.Reflection.MethodInfo method, System.Linq.Expressions.LambdaExpression conversion)
		{
			
			Gate.NotEmpty(exprStack);
			Expression right = exprStack.Pop();
			Contract.Assume(right != null);
			Gate.NotEmpty(exprStack);
			Expression left = exprStack.Pop();
			Contract.Assume(left != null);
			var expr = Expression.MultiplyAssignChecked(left, right, method, conversion);
			exprStack.Push(expr);
		}
		
		public void MultiplyChecked()
		{
			
			Gate.NotEmpty(exprStack);
			Expression right = exprStack.Pop();
			Contract.Assume(right != null);
			Gate.NotEmpty(exprStack);
			Expression left = exprStack.Pop();
			Contract.Assume(left != null);
			var expr = Expression.MultiplyChecked(left, right);
			exprStack.Push(expr);
		}
		
		public void MultiplyChecked(System.Reflection.MethodInfo method)
		{
			
			Gate.NotEmpty(exprStack);
			Expression right = exprStack.Pop();
			Contract.Assume(right != null);
			Gate.NotEmpty(exprStack);
			Expression left = exprStack.Pop();
			Contract.Assume(left != null);
			var expr = Expression.MultiplyChecked(left, right, method);
			exprStack.Push(expr);
		}
		
		public void LeftShift()
		{
			
			Gate.NotEmpty(exprStack);
			Expression right = exprStack.Pop();
			Contract.Assume(right != null);
			Gate.NotEmpty(exprStack);
			Expression left = exprStack.Pop();
			Contract.Assume(left != null);
			var expr = Expression.LeftShift(left, right);
			exprStack.Push(expr);
		}
		
		public void LeftShift(System.Reflection.MethodInfo method)
		{
			
			Gate.NotEmpty(exprStack);
			Expression right = exprStack.Pop();
			Contract.Assume(right != null);
			Gate.NotEmpty(exprStack);
			Expression left = exprStack.Pop();
			Contract.Assume(left != null);
			var expr = Expression.LeftShift(left, right, method);
			exprStack.Push(expr);
		}
		
		public void LeftShiftAssign()
		{
			
			Gate.NotEmpty(exprStack);
			Expression right = exprStack.Pop();
			Contract.Assume(right != null);
			Gate.NotEmpty(exprStack);
			Expression left = exprStack.Pop();
			Contract.Assume(left != null);
			var expr = Expression.LeftShiftAssign(left, right);
			exprStack.Push(expr);
		}
		
		public void LeftShiftAssign(System.Reflection.MethodInfo method)
		{
			
			Gate.NotEmpty(exprStack);
			Expression right = exprStack.Pop();
			Contract.Assume(right != null);
			Gate.NotEmpty(exprStack);
			Expression left = exprStack.Pop();
			Contract.Assume(left != null);
			var expr = Expression.LeftShiftAssign(left, right, method);
			exprStack.Push(expr);
		}
		
		public void LeftShiftAssign(System.Reflection.MethodInfo method, System.Linq.Expressions.LambdaExpression conversion)
		{
			
			Gate.NotEmpty(exprStack);
			Expression right = exprStack.Pop();
			Contract.Assume(right != null);
			Gate.NotEmpty(exprStack);
			Expression left = exprStack.Pop();
			Contract.Assume(left != null);
			var expr = Expression.LeftShiftAssign(left, right, method, conversion);
			exprStack.Push(expr);
		}
		
		public void RightShift()
		{
			
			Gate.NotEmpty(exprStack);
			Expression right = exprStack.Pop();
			Contract.Assume(right != null);
			Gate.NotEmpty(exprStack);
			Expression left = exprStack.Pop();
			Contract.Assume(left != null);
			var expr = Expression.RightShift(left, right);
			exprStack.Push(expr);
		}
		
		public void RightShift(System.Reflection.MethodInfo method)
		{
			
			Gate.NotEmpty(exprStack);
			Expression right = exprStack.Pop();
			Contract.Assume(right != null);
			Gate.NotEmpty(exprStack);
			Expression left = exprStack.Pop();
			Contract.Assume(left != null);
			var expr = Expression.RightShift(left, right, method);
			exprStack.Push(expr);
		}
		
		public void RightShiftAssign()
		{
			
			Gate.NotEmpty(exprStack);
			Expression right = exprStack.Pop();
			Contract.Assume(right != null);
			Gate.NotEmpty(exprStack);
			Expression left = exprStack.Pop();
			Contract.Assume(left != null);
			var expr = Expression.RightShiftAssign(left, right);
			exprStack.Push(expr);
		}
		
		public void RightShiftAssign(System.Reflection.MethodInfo method)
		{
			
			Gate.NotEmpty(exprStack);
			Expression right = exprStack.Pop();
			Contract.Assume(right != null);
			Gate.NotEmpty(exprStack);
			Expression left = exprStack.Pop();
			Contract.Assume(left != null);
			var expr = Expression.RightShiftAssign(left, right, method);
			exprStack.Push(expr);
		}
		
		public void RightShiftAssign(System.Reflection.MethodInfo method, System.Linq.Expressions.LambdaExpression conversion)
		{
			
			Gate.NotEmpty(exprStack);
			Expression right = exprStack.Pop();
			Contract.Assume(right != null);
			Gate.NotEmpty(exprStack);
			Expression left = exprStack.Pop();
			Contract.Assume(left != null);
			var expr = Expression.RightShiftAssign(left, right, method, conversion);
			exprStack.Push(expr);
		}
		
		public void And()
		{
			
			Gate.NotEmpty(exprStack);
			Expression right = exprStack.Pop();
			Contract.Assume(right != null);
			Gate.NotEmpty(exprStack);
			Expression left = exprStack.Pop();
			Contract.Assume(left != null);
			var expr = Expression.And(left, right);
			exprStack.Push(expr);
		}
		
		public void And(System.Reflection.MethodInfo method)
		{
			
			Gate.NotEmpty(exprStack);
			Expression right = exprStack.Pop();
			Contract.Assume(right != null);
			Gate.NotEmpty(exprStack);
			Expression left = exprStack.Pop();
			Contract.Assume(left != null);
			var expr = Expression.And(left, right, method);
			exprStack.Push(expr);
		}
		
		public void AndAssign()
		{
			
			Gate.NotEmpty(exprStack);
			Expression right = exprStack.Pop();
			Contract.Assume(right != null);
			Gate.NotEmpty(exprStack);
			Expression left = exprStack.Pop();
			Contract.Assume(left != null);
			var expr = Expression.AndAssign(left, right);
			exprStack.Push(expr);
		}
		
		public void AndAssign(System.Reflection.MethodInfo method)
		{
			
			Gate.NotEmpty(exprStack);
			Expression right = exprStack.Pop();
			Contract.Assume(right != null);
			Gate.NotEmpty(exprStack);
			Expression left = exprStack.Pop();
			Contract.Assume(left != null);
			var expr = Expression.AndAssign(left, right, method);
			exprStack.Push(expr);
		}
		
		public void AndAssign(System.Reflection.MethodInfo method, System.Linq.Expressions.LambdaExpression conversion)
		{
			
			Gate.NotEmpty(exprStack);
			Expression right = exprStack.Pop();
			Contract.Assume(right != null);
			Gate.NotEmpty(exprStack);
			Expression left = exprStack.Pop();
			Contract.Assume(left != null);
			var expr = Expression.AndAssign(left, right, method, conversion);
			exprStack.Push(expr);
		}
		
		public void Or()
		{
			
			Gate.NotEmpty(exprStack);
			Expression right = exprStack.Pop();
			Contract.Assume(right != null);
			Gate.NotEmpty(exprStack);
			Expression left = exprStack.Pop();
			Contract.Assume(left != null);
			var expr = Expression.Or(left, right);
			exprStack.Push(expr);
		}
		
		public void Or(System.Reflection.MethodInfo method)
		{
			
			Gate.NotEmpty(exprStack);
			Expression right = exprStack.Pop();
			Contract.Assume(right != null);
			Gate.NotEmpty(exprStack);
			Expression left = exprStack.Pop();
			Contract.Assume(left != null);
			var expr = Expression.Or(left, right, method);
			exprStack.Push(expr);
		}
		
		public void OrAssign()
		{
			
			Gate.NotEmpty(exprStack);
			Expression right = exprStack.Pop();
			Contract.Assume(right != null);
			Gate.NotEmpty(exprStack);
			Expression left = exprStack.Pop();
			Contract.Assume(left != null);
			var expr = Expression.OrAssign(left, right);
			exprStack.Push(expr);
		}
		
		public void OrAssign(System.Reflection.MethodInfo method)
		{
			
			Gate.NotEmpty(exprStack);
			Expression right = exprStack.Pop();
			Contract.Assume(right != null);
			Gate.NotEmpty(exprStack);
			Expression left = exprStack.Pop();
			Contract.Assume(left != null);
			var expr = Expression.OrAssign(left, right, method);
			exprStack.Push(expr);
		}
		
		public void OrAssign(System.Reflection.MethodInfo method, System.Linq.Expressions.LambdaExpression conversion)
		{
			
			Gate.NotEmpty(exprStack);
			Expression right = exprStack.Pop();
			Contract.Assume(right != null);
			Gate.NotEmpty(exprStack);
			Expression left = exprStack.Pop();
			Contract.Assume(left != null);
			var expr = Expression.OrAssign(left, right, method, conversion);
			exprStack.Push(expr);
		}
		
		public void ExclusiveOr()
		{
			
			Gate.NotEmpty(exprStack);
			Expression right = exprStack.Pop();
			Contract.Assume(right != null);
			Gate.NotEmpty(exprStack);
			Expression left = exprStack.Pop();
			Contract.Assume(left != null);
			var expr = Expression.ExclusiveOr(left, right);
			exprStack.Push(expr);
		}
		
	}
}

